home *** CD-ROM | disk | FTP | other *** search
/ PC Media 7 / PC MEDIA CD07.iso / share / os2 / vipf / ipf.mod < prev    next >
Encoding:
Modula Implementation  |  1994-03-17  |  7.8 KB  |  223 lines
  1. IMPLEMENTATION MODULE IPF;
  2.  
  3.   FROM SYSTEM   IMPORT TSIZE, BYTE, WORD, LONGWORD;
  4.   FROM Storage  IMPORT ALLOCATE, DEALLOCATE;
  5.                 IMPORT Str, Err, DiskIO, Lib, IO;
  6.  
  7.   TYPE
  8.     aFileOfs =          LONGCARD;
  9.     aFileLength =       LONGCARD;
  10.  
  11.   (*-------------------------------------------------- header *)
  12.  
  13.   TYPE
  14.     aHeader =           RECORD
  15.       ID:                 CARDINAL;     (* magic "HS" *)
  16.       unknown1:           BYTE;
  17.       flags:              BYTESET;      (* says .INF or .HLP *)
  18.       headerSize:         aLength;      (* total size of header *)
  19.       unknown2:           WORD;
  20.       tocCnt:             aCount;       (* no of entries in table-of-contents *)
  21.       tocStrStart:        aFileOfs;     (* table of toc strings *)
  22.       tocStrLen:          aFileLength;
  23.       tocStart:           aFileOfs;     (* array of aTocEntryRef *)
  24.       resCnt:             aCount;       (* no of panels with resource nos *)
  25.       resStart:           aFileOfs;     (* resource number table *)
  26.       nameCnt:            aCount;       (* no of panels with names *)
  27.       nameStart:          aFileOfs;     (* panel name table *)
  28.       idxCnt:             aCount;       (* no of index entries *)
  29.       idxStart:           aFileOfs;     (* index table *)
  30.       idxLen:             aFileLength;
  31.       unknown3:           ARRAY [1..10] OF BYTE;
  32.       searchStart:        aFileOfs;     (* start of full-text search table *)
  33.       searchLen:          aFileLength;
  34.       slotCnt:            aCount;       (* number of slots *)
  35.       slotStart:          aFileOfs;     (* slot table *)
  36.       dictLen:            aFileLength;  (* length of dictionary *)
  37.       dictCnt:            aCount;       (* no of entries in dictionary *)
  38.       dictStart:          aFileOfs;     (* start of dictionary *)
  39.       imgStart:           aFileOfs;     (* start of image data *)
  40.       unknown4:           BYTE;
  41.       nlsStart:           aFileOfs;     (* NLS data *)
  42.       nlsLen:             aFileLength;
  43.       extStart:           aFileOfs;     (* extended block *)
  44.       unknown5:           ARRAY [1..12] OF BYTE;
  45.       title:              ARRAY [0..47] OF CHAR;  (* title of document *)
  46.                         END;
  47.  
  48.   VAR
  49.     Input:              DiskIO.aFile;
  50.     Header:             aHeader;
  51.  
  52.   (*-------------------------------------------------- references *)
  53.  
  54.   TYPE
  55.     aRef =              POINTER TO ARRAY anIndex OF aFileOfs;
  56.  
  57.   PROCEDURE ReadRef (VAR r: aRef; at: aFileOfs; cnt: aCount);
  58.     BEGIN
  59.       ALLOCATE( r, cnt * TSIZE(aFileOfs) );
  60.       DiskIO.MoveTo( Input, at );
  61.       DiskIO.ReadBlock( Input, r^, cnt * TSIZE(aFileOfs) );
  62.     END ReadRef;
  63.  
  64.   (*-------------------------------------------------- table-of-contents *)
  65.  
  66.   PROCEDURE ReadToc;
  67.     VAR
  68.       toc:      aRef;
  69.       i:        anIndex;
  70.       e:        aTocPtr;
  71.       ll:       SHORTCARD;
  72.       l:        aLength;
  73.       skip:     aLength;
  74.       w1,w2:    BYTESET;
  75.     BEGIN
  76.       IO.WrLn; IO.WrStr( "Reading " ); IO.WrCard( Header.tocCnt,0 );
  77.       IO.WrStr( " table-of-contents entries..." );
  78.       TocCnt:= Header.tocCnt;
  79.       ReadRef( toc, Header.tocStart, Header.tocCnt );
  80.       ALLOCATE( Toc, Header.tocCnt * TSIZE(ADDRESS) );
  81.       FOR i:= 0 TO Header.tocCnt-1 DO
  82.         NEW( Toc^[i] );
  83.         WITH Toc^[i]^ DO
  84.           DiskIO.MoveTo( Input, toc^[i] );
  85.           DiskIO.Read( Input, ll );  l:= VAL(CARDINAL,ll);
  86.           DiskIO.Read( Input, flags );
  87.           nest:= VAL(CARDINAL, SHORTCARD(flags) MOD 16 );
  88.           DiskIO.Read( Input, ll ); slotCnt:= VAL(aCount,ll);
  89.           ALLOCATE( slot, slotCnt * TSIZE(anIndex) );
  90.           IF Extended IN flags THEN
  91.             DiskIO.Read( Input, w1 );
  92.             DiskIO.Read( Input, w2 );
  93.             skip:= 0;
  94.             IF 0 IN w1 THEN INC(skip,5) END;
  95.             IF 1 IN w1 THEN INC(skip,5) END;
  96.             IF 3 IN w1 THEN INC(skip,2) END;
  97.             IF 2 IN w2 THEN INC(skip,2) END;
  98.             DiskIO.MoveTo( Input, DiskIO.Pos(Input) + VAL(LONGCARD,skip) );
  99.           END;
  100.           DiskIO.ReadBlock( Input, slot^, slotCnt * TSIZE(anIndex) );
  101.           l:= l - VAL(INTEGER, DiskIO.Pos(Input) - toc^[i] );
  102.           ALLOCATE( title, l+1 );
  103.           DiskIO.ReadBlock( Input, title^, l );
  104.           title^[l]:= 0C;
  105.         END;
  106.       END;
  107.       DEALLOCATE( toc, Header.tocCnt * TSIZE(aFileOfs) );
  108.     END ReadToc;
  109.  
  110.  
  111.   (*-------------------------------------------------- index *)
  112.  
  113.   PROCEDURE ReadIdx;
  114.     VAR
  115.       i:        anIndex;
  116.       l:        aLength;
  117.       ll:       SHORTCARD;
  118.     BEGIN
  119.       IO.WrLn; IO.WrStr( "Reading " ); IO.WrCard( Header.idxCnt,0 );
  120.       IO.WrStr( " index entries..." );
  121.       IdxCnt:= Header.idxCnt;
  122.       IF Header.idxCnt = 0 THEN RETURN END;
  123.       DiskIO.MoveTo( Input, Header.idxStart );
  124.       ALLOCATE( Idx, Header.idxCnt * TSIZE(anIdxEntry) );
  125.       FOR i:= 0 TO Header.idxCnt-1 DO
  126.         NEW( Idx^[i] );
  127.         WITH Idx^[i]^ DO
  128.           DiskIO.Read( Input, ll );  l:= VAL(CARDINAL,ll);
  129.           DiskIO.Read( Input, ll );  level:= VAL(CARDINAL,ll);
  130.           DiskIO.Read( Input, ll );
  131.           DiskIO.Read( Input, toc );
  132.           ALLOCATE( name, l+1 );
  133.           DiskIO.ReadBlock( Input, name^, l );
  134.           name^[l]:= 0C;
  135.         END;
  136.       END;
  137.     END ReadIdx;
  138.  
  139.  
  140.   (*-------------------------------------------------- dictionary *)
  141.  
  142.   VAR
  143.     DictWords:          POINTER TO ARRAY [0..65530] OF CHAR;
  144.  
  145.   PROCEDURE ReadDict;
  146.     VAR
  147.       i: anIndex;
  148.       p, pp: CARDINAL;
  149.     BEGIN
  150.       IO.WrLn; IO.WrStr( "Reading " ); IO.WrCard( Header.dictCnt,0 );
  151.       IO.WrStr( " dictionary entries..." );
  152.       DictCnt:= Header.dictCnt;
  153.       ALLOCATE( Dict, Header.dictCnt * TSIZE(ADDRESS) );
  154.       ALLOCATE( DictWords, VAL(CARDINAL,Header.dictLen) + 1);
  155.       DiskIO.MoveTo( Input, Header.dictStart );
  156.       DiskIO.ReadBlock( Input, DictWords^, VAL(CARDINAL,Header.dictLen) );
  157.       DictWords^[VAL(CARDINAL,Header.dictLen)]:= 0C;
  158.       p:= 0;
  159.       FOR i:= 0 TO Header.dictCnt-1 DO
  160.         Dict^[i]:= ADR(DictWords^[p+1]);
  161.         pp:= p + VAL(CARDINAL, SHORTCARD(DictWords^[p]) );
  162.         DictWords^[p]:= 0C;
  163.         p:= pp;
  164.       END;
  165.     END ReadDict;
  166.  
  167.   (*-------------------------------------------------- slots *)
  168.  
  169.   PROCEDURE ReadSlots;
  170.     VAR
  171.       ofs:      aRef;
  172.       localOfs: aFileOfs;
  173.       i:        anIndex;
  174.       stuff:    BYTE;
  175.     BEGIN
  176.       IO.WrLn; IO.WrStr( "Reading " ); IO.WrCard( Header.slotCnt,0 );
  177.       IO.WrStr( " slots..." );
  178.       SlotCnt:= Header.slotCnt;
  179.       ALLOCATE( Slot, Header.slotCnt * TSIZE(ADDRESS) );
  180.       ReadRef( ofs, Header.slotStart, Header.slotCnt );
  181.       FOR i:= 0 TO Header.slotCnt-1 DO
  182.         NEW(Slot^[i]);
  183.         WITH Slot^[i]^ DO
  184.           DiskIO.MoveTo( Input, ofs^[i] );
  185.           DiskIO.Read( Input, stuff );
  186.           DiskIO.Read( Input, localOfs );
  187.           DiskIO.Read( Input, localCnt );
  188.           DiskIO.Read( Input, textCnt );
  189.           ALLOCATE( text, textCnt * TSIZE(aWord) );
  190.           DiskIO.ReadBlock( Input, text^, textCnt * TSIZE(aWord) );
  191.           ALLOCATE( local, VAL(CARDINAL,localCnt) * TSIZE(anIndex) );
  192.           DiskIO.MoveTo( Input, localOfs );
  193.           DiskIO.ReadBlock( Input, local^, VAL(CARDINAL,localCnt) * TSIZE(anIndex) );
  194.         END;
  195.       END;
  196.       DEALLOCATE( ofs, Header.slotCnt * TSIZE(aFileOfs) );
  197.     END ReadSlots;
  198.  
  199.   (*-------------------------------------------------- globals *)
  200.  
  201.   PROCEDURE Open (fname: ARRAY OF CHAR);
  202.     BEGIN
  203.       IF DiskIO.Open( Input, fname ) THEN
  204.         DiskIO.Read( Input, Header );
  205.         Str.Assign( Title, Header.title );
  206.         IO.WrStr( Title );
  207.         ReadToc;
  208.         ReadIdx;
  209.         ReadDict;
  210.         ReadSlots;
  211.       ELSE
  212.         Err.Fatal( "Cannot open .INF file." );
  213.       END;
  214.     END Open;
  215.  
  216.   PROCEDURE Close;
  217.     BEGIN
  218.       DiskIO.Close( Input );
  219.     END Close;
  220.  
  221.  
  222. END IPF.
  223.